home *** CD-ROM | disk | FTP | other *** search
/ Developer CD Series 1996 May: Tool Chest / Developer CD Series May 1996 (Tool Chest) (Apple Computer) (1996).iso / Tool Chest / Interfaces & Libraries / Interfaces / PInterfaces / PPCToolbox.p < prev    next >
Encoding:
Text File  |  1995-07-06  |  14.9 KB  |  509 lines  |  [TEXT/MPS ]
  1. {
  2.      File:        PPCToolbox.p
  3.  
  4.      Contains:    Program-Program Communications Toolbox Interfaces.
  5.  
  6.      Version:    Technology:    System 7.5
  7.                  Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18
  8.  
  9.      Copyright:    © 1984-1995 by Apple Computer, Inc.
  10.                  All rights reserved.
  11.  
  12.      Bugs?:        If you find a problem with this file, use the Apple Bug Reporter
  13.                  stack.  Include the file and version information (from above)
  14.                  in the problem description and send to:
  15.                      Internet:    apple.bugs@applelink.apple.com
  16.                      AppleLink:    APPLE.BUGS
  17.  
  18. }
  19.  
  20. {$IFC UNDEFINED UsingIncludes}
  21. {$SETC UsingIncludes := 0}
  22. {$ENDC}
  23.  
  24. {$IFC NOT UsingIncludes}
  25.  UNIT PPCToolbox;
  26.  INTERFACE
  27. {$ENDC}
  28.  
  29. {$IFC UNDEFINED __PPCTOOLBOX__}
  30. {$SETC __PPCTOOLBOX__ := 1}
  31.  
  32. {$I+}
  33. {$SETC PPCToolboxIncludes := UsingIncludes}
  34. {$SETC UsingIncludes := 1}
  35.  
  36.  
  37. {$IFC UNDEFINED __APPLETALK__}
  38. {$I AppleTalk.p}
  39. {$ENDC}
  40. {    Types.p                                                        }
  41. {        ConditionalMacros.p                                        }
  42. {    OSUtils.p                                                    }
  43. {        MixedMode.p                                                }
  44. {        Memory.p                                                }
  45.  
  46. {$IFC UNDEFINED __MEMORY__}
  47. {$I Memory.p}
  48. {$ENDC}
  49.  
  50. {$IFC UNDEFINED __TYPES__}
  51. {$I Types.p}
  52. {$ENDC}
  53.  
  54. {$PUSH}
  55. {$ALIGN MAC68K}
  56. {$LibExport+}
  57.     
  58. TYPE
  59.     PPCServiceType = CHAR;
  60.  
  61.  
  62. CONST
  63.     ppcServiceRealTime            = 1;
  64.  
  65.     
  66. TYPE
  67.     PPCLocationKind = INTEGER;
  68.  
  69.  
  70. CONST
  71.     ppcNoLocation                = 0;                            { There is no PPCLocName }
  72.     ppcNBPLocation                = 1;                            { Use AppleTalk NBP      }
  73.     ppcNBPTypeLocation            = 2;                            { Used for specifying a location name type during PPCOpen only }
  74.  
  75.     
  76. TYPE
  77.     PPCPortKinds = INTEGER;
  78.  
  79.  
  80. CONST
  81.     ppcByCreatorAndType            = 1;                            { Port type is specified as colloquial Mac creator and type }
  82.     ppcByString                    = 2;                            { Port type is in pascal string format }
  83.  
  84. { Values returned for request field in PPCInform call }
  85.     
  86. TYPE
  87.     PPCSessionOrigin = CHAR;
  88.  
  89.  
  90. CONST
  91. { Values returned for requestType field in PPCInform call }
  92.     ppcLocalOrigin                = 1;                            { session originated from this machine }
  93.     ppcRemoteOrigin                = 2;                            { session originated from remote machine }
  94.  
  95.     
  96. TYPE
  97.     PPCPortRefNum = INTEGER;
  98.  
  99.     PPCSessRefNum = LONGINT;
  100.  
  101.     PPCPortRec = RECORD
  102.         nameScript:                ScriptCode;                                { script of name }
  103.         name:                    Str32;                                    { name of port as seen in browser }
  104.         portKindSelector:        PPCPortKinds;                            { which variant }
  105.         CASE INTEGER OF
  106.         0: (
  107.             portTypeStr:                Str32;                                { pascal type string }
  108.            );
  109.         1: (
  110.             portCreator:                OSType;
  111.             portType:                    OSType;
  112.            );
  113.     END;
  114.  
  115.     PPCPortPtr = ^PPCPortRec;
  116.  
  117.     LocationNameRec = RECORD
  118.         locationKindSelector:    PPCLocationKind;                        { which variant }
  119.         CASE INTEGER OF
  120.         0: (
  121.             nbpEntity:                    EntityName;                            { NBP name entity }
  122.            );
  123.         1: (
  124.             nbpType:                    Str32;                                { just the NBP type string, for PPCOpen }
  125.            );
  126.     END;
  127.  
  128.     LocationNamePtr = ^LocationNameRec;
  129.  
  130.     PortInfoRec = RECORD
  131.         filler1:                SInt8; (* unsigned char *)
  132.         authRequired:            BOOLEAN;
  133.         name:                    PPCPortRec;
  134.     END;
  135.  
  136.     PortInfoPtr = ^PortInfoRec;
  137.  
  138.     PortInfoArrayPtr = ^PortInfoRec;
  139.  
  140.     PPCParamBlockPtr = ^PPCParamBlockRec;
  141.  
  142.     PPCCompProcPtr = ProcPtr;  { PROCEDURE PPCComp(pb: PPCParamBlockPtr); }
  143.     PPCCompUPP = UniversalProcPtr;
  144.  
  145.     PPCOpenPBRec = PACKED RECORD
  146.         qLink:                    Ptr;
  147.         csCode:                    INTEGER;
  148.         intUse:                    INTEGER;
  149.         intUsePtr:                Ptr;
  150.         ioCompletion:            PPCCompUPP;
  151.         ioResult:                OSErr;
  152.         Reserved:                ARRAY [0..4] OF LONGINT;
  153.         portRefNum:                PPCPortRefNum;                            { 38 <--   Port Reference }
  154.         filler1:                LONGINT;
  155.         serviceType:            PPCServiceType;                            { 44 -->    Bit field describing the requested port service }
  156.         resFlag:                UInt8;                                    { Must be set to 0 }
  157.         portName:                PPCPortPtr;                                { 46 -->   PortName for PPC }
  158.         locationName:            LocationNamePtr;                        { 50 -->   If NBP Registration is required }
  159.         networkVisible:            BOOLEAN;                                { 54 -->   make this network visible on network }
  160.         nbpRegistered:            BOOLEAN;                                { 55 <--   The given location name was registered on the network }
  161.     END;
  162.  
  163.     PPCOpenPBPtr = ^PPCOpenPBRec;
  164.  
  165.     PPCInformPBRec = PACKED RECORD
  166.         qLink:                    Ptr;
  167.         csCode:                    INTEGER;
  168.         intUse:                    INTEGER;
  169.         intUsePtr:                Ptr;
  170.         ioCompletion:            PPCCompUPP;
  171.         ioResult:                OSErr;
  172.         Reserved:                ARRAY [0..4] OF LONGINT;
  173.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  174.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  175.         serviceType:            PPCServiceType;                            { 44 <--   Status Flags for type of session, local, remote }
  176.         autoAccept:                BOOLEAN;                                { 45 -->   if true session will be accepted automatically }
  177.         portName:                PPCPortPtr;                                { 46 -->   Buffer for Source PPCPortRec }
  178.         locationName:            LocationNamePtr;                        { 50 -->   Buffer for Source LocationNameRec }
  179.         userName:                StringPtr;                                { 54 -->   Buffer for Soure user's name trying to link. }
  180.         userData:                LONGINT;                                { 58 <--   value included in PPCStart's userData }
  181.         requestType:            PPCSessionOrigin;                        { 62 <--   Local or Network }
  182.     END;
  183.  
  184.     PPCInformPBPtr = ^PPCInformPBRec;
  185.  
  186.     PPCStartPBRec = PACKED RECORD
  187.         qLink:                    Ptr;
  188.         csCode:                    INTEGER;
  189.         intUse:                    INTEGER;
  190.         intUsePtr:                Ptr;
  191.         ioCompletion:            PPCCompUPP;
  192.         ioResult:                OSErr;
  193.         Reserved:                ARRAY [0..4] OF LONGINT;
  194.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  195.         sessRefNum:                PPCSessRefNum;                            { 40 <--   Session Reference }
  196.         serviceType:            PPCServiceType;                            { 44 <--   Actual service method (realTime) }
  197.         resFlag:                UInt8;                                    { 45 -->   Must be set to 0  }
  198.         portName:                PPCPortPtr;                                { 46 -->   Destination portName }
  199.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS style service location name }
  200.         rejectInfo:                LONGINT;                                { 54 <--   reason for rejecting the session request }
  201.         userData:                LONGINT;                                { 58 -->   Copied to destination PPCInform parameter block }
  202.         userRefNum:                LONGINT;                                { 62 -->   userRefNum (obtained during login process)  }
  203.     END;
  204.  
  205.     PPCStartPBPtr = ^PPCStartPBRec;
  206.  
  207.     PPCAcceptPBRec = RECORD
  208.         qLink:                    Ptr;
  209.         csCode:                    INTEGER;
  210.         intUse:                    INTEGER;
  211.         intUsePtr:                Ptr;
  212.         ioCompletion:            PPCCompUPP;
  213.         ioResult:                OSErr;
  214.         Reserved:                ARRAY [0..4] OF LONGINT;
  215.         filler1:                INTEGER;
  216.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  217.     END;
  218.  
  219.     PPCAcceptPBPtr = ^PPCAcceptPBRec;
  220.  
  221.     PPCRejectPBRec = RECORD
  222.         qLink:                    Ptr;
  223.         csCode:                    INTEGER;
  224.         intUse:                    INTEGER;
  225.         intUsePtr:                Ptr;
  226.         ioCompletion:            PPCCompUPP;
  227.         ioResult:                OSErr;
  228.         Reserved:                ARRAY [0..4] OF LONGINT;
  229.         filler1:                INTEGER;
  230.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  231.         filler2:                INTEGER;
  232.         filler3:                LONGINT;
  233.         filler4:                LONGINT;
  234.         rejectInfo:                LONGINT;                                { 54 -->   reason for rejecting the session request  }
  235.     END;
  236.  
  237.     PPCRejectPBPtr = ^PPCRejectPBRec;
  238.  
  239.     PPCWritePBRec = RECORD
  240.         qLink:                    Ptr;
  241.         csCode:                    INTEGER;
  242.         intUse:                    INTEGER;
  243.         intUsePtr:                Ptr;
  244.         ioCompletion:            PPCCompUPP;
  245.         ioResult:                OSErr;
  246.         Reserved:                ARRAY [0..4] OF LONGINT;
  247.         filler1:                INTEGER;
  248.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  249.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  250.         actualLength:            Size;                                    { 48 <--   Actual Length Written }
  251.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  252.         more:                    BOOLEAN;                                { 56 -->   if more data in this block will be written }
  253.         filler2:                SInt8; (* unsigned char *)
  254.         userData:                LONGINT;                                { 58 -->   Message block userData Uninterpreted by PPC }
  255.         blockCreator:            OSType;                                    { 62 -->   Message block creator Uninterpreted by PPC }
  256.         blockType:                OSType;                                    { 66 -->   Message block type Uninterpreted by PPC }
  257.     END;
  258.  
  259.     PPCWritePBPtr = ^PPCWritePBRec;
  260.  
  261.     PPCReadPBRec = RECORD
  262.         qLink:                    Ptr;
  263.         csCode:                    INTEGER;
  264.         intUse:                    INTEGER;
  265.         intUsePtr:                Ptr;
  266.         ioCompletion:            PPCCompUPP;
  267.         ioResult:                OSErr;
  268.         Reserved:                ARRAY [0..4] OF LONGINT;
  269.         filler1:                INTEGER;
  270.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  271.         bufferLength:            Size;                                    { 44 -->   Length of the message buffer }
  272.         actualLength:            Size;                                    { 48 <--   Actual length read }
  273.         bufferPtr:                Ptr;                                    { 52 -->   Pointer to message buffer }
  274.         more:                    BOOLEAN;                                { 56 <--   if true more data in this block to be read }
  275.         filler2:                SInt8; (* unsigned char *)
  276.         userData:                LONGINT;                                { 58 <--   Message block userData Uninterpreted by PPC }
  277.         blockCreator:            OSType;                                    { 62 <--   Message block creator Uninterpreted by PPC }
  278.         blockType:                OSType;                                    { 66 <--   Message block type Uninterpreted by PPC }
  279.     END;
  280.  
  281.     PPCReadPBPtr = ^PPCReadPBRec;
  282.  
  283.     PPCEndPBRec = RECORD
  284.         qLink:                    Ptr;
  285.         csCode:                    INTEGER;
  286.         intUse:                    INTEGER;
  287.         intUsePtr:                Ptr;
  288.         ioCompletion:            PPCCompUPP;
  289.         ioResult:                OSErr;
  290.         Reserved:                ARRAY [0..4] OF LONGINT;
  291.         filler1:                INTEGER;
  292.         sessRefNum:                PPCSessRefNum;                            { 40 -->   Session Reference }
  293.     END;
  294.  
  295.     PPCEndPBPtr = ^PPCEndPBRec;
  296.  
  297.     PPCClosePBRec = RECORD
  298.         qLink:                    Ptr;
  299.         csCode:                    INTEGER;
  300.         intUse:                    INTEGER;
  301.         intUsePtr:                Ptr;
  302.         ioCompletion:            PPCCompUPP;
  303.         ioResult:                OSErr;
  304.         Reserved:                ARRAY [0..4] OF LONGINT;
  305.         portRefNum:                PPCPortRefNum;                            { 38 -->   Port Identifier }
  306.     END;
  307.  
  308.     PPCClosePBPtr = ^PPCClosePBRec;
  309.  
  310.     IPCListPortsPBRec = RECORD
  311.         qLink:                    Ptr;
  312.         csCode:                    INTEGER;
  313.         intUse:                    INTEGER;
  314.         intUsePtr:                Ptr;
  315.         ioCompletion:            PPCCompUPP;
  316.         ioResult:                OSErr;
  317.         Reserved:                ARRAY [0..4] OF LONGINT;
  318.         filler1:                INTEGER;
  319.         startIndex:                INTEGER;                                { 40 -->   Start Index }
  320.         requestCount:            INTEGER;                                { 42 -->   Number of entries to be returned }
  321.         actualCount:            INTEGER;                                { 44 <--   Actual Number of entries to be returned }
  322.         portName:                PPCPortPtr;                                { 46 -->   PortName Match }
  323.         locationName:            LocationNamePtr;                        { 50 -->   NBP or NAS type name to locate the Port Location }
  324.         bufferPtr:                PortInfoArrayPtr;                        { 54 -->   Pointer to a buffer requestCount*sizeof(PortInfo) bytes big }
  325.     END;
  326.  
  327.     IPCListPortsPBPtr = ^IPCListPortsPBRec;
  328.  
  329.     PPCParamBlockRec = RECORD
  330.         CASE INTEGER OF
  331.         0: (
  332.             openParam:                    PPCOpenPBRec;
  333.            );
  334.         1: (
  335.             informParam:                PPCInformPBRec;
  336.            );
  337.         2: (
  338.             startParam:                    PPCStartPBRec;
  339.            );
  340.         3: (
  341.             acceptParam:                PPCAcceptPBRec;
  342.            );
  343.         4: (
  344.             rejectParam:                PPCRejectPBRec;
  345.            );
  346.         5: (
  347.             writeParam:                    PPCWritePBRec;
  348.            );
  349.         6: (
  350.             readParam:                    PPCReadPBRec;
  351.            );
  352.         7: (
  353.             endParam:                    PPCEndPBRec;
  354.            );
  355.         8: (
  356.             closeParam:                    PPCClosePBRec;
  357.            );
  358.         9: (
  359.             listPortsParam:                IPCListPortsPBRec;
  360.            );
  361.     END;
  362.  
  363.  
  364. FUNCTION PPCInit: OSErr;
  365.     {$IFC NOT GENERATINGCFM}
  366.     INLINE $7000, $A0DD, $3E80;
  367.     {$ENDC}
  368. FUNCTION PPCOpenSync(pb: PPCOpenPBPtr): OSErr;
  369.     {$IFC NOT GENERATINGCFM}
  370.     INLINE $205F, $7001, $A0DD, $3E80;
  371.     {$ENDC}
  372. FUNCTION PPCOpenAsync(pb: PPCOpenPBPtr): OSErr;
  373.     {$IFC NOT GENERATINGCFM}
  374.     INLINE $205F, $7001, $A4DD, $3E80;
  375.     {$ENDC}
  376. FUNCTION PPCInformSync(pb: PPCInformPBPtr): OSErr;
  377.     {$IFC NOT GENERATINGCFM}
  378.     INLINE $205F, $7003, $A0DD, $3E80;
  379.     {$ENDC}
  380. FUNCTION PPCInformAsync(pb: PPCInformPBPtr): OSErr;
  381.     {$IFC NOT GENERATINGCFM}
  382.     INLINE $205F, $7003, $A4DD, $3E80;
  383.     {$ENDC}
  384. FUNCTION PPCStartSync(pb: PPCStartPBPtr): OSErr;
  385.     {$IFC NOT GENERATINGCFM}
  386.     INLINE $205F, $7002, $A0DD, $3E80;
  387.     {$ENDC}
  388. FUNCTION PPCStartAsync(pb: PPCStartPBPtr): OSErr;
  389.     {$IFC NOT GENERATINGCFM}
  390.     INLINE $205F, $7002, $A4DD, $3E80;
  391.     {$ENDC}
  392. FUNCTION PPCAcceptSync(pb: PPCAcceptPBPtr): OSErr;
  393.     {$IFC NOT GENERATINGCFM}
  394.     INLINE $205F, $7004, $A0DD, $3E80;
  395.     {$ENDC}
  396. FUNCTION PPCAcceptAsync(pb: PPCAcceptPBPtr): OSErr;
  397.     {$IFC NOT GENERATINGCFM}
  398.     INLINE $205F, $7004, $A4DD, $3E80;
  399.     {$ENDC}
  400. FUNCTION PPCRejectSync(pb: PPCRejectPBPtr): OSErr;
  401.     {$IFC NOT GENERATINGCFM}
  402.     INLINE $205F, $7005, $A0DD, $3E80;
  403.     {$ENDC}
  404. FUNCTION PPCRejectAsync(pb: PPCRejectPBPtr): OSErr;
  405.     {$IFC NOT GENERATINGCFM}
  406.     INLINE $205F, $7005, $A4DD, $3E80;
  407.     {$ENDC}
  408. FUNCTION PPCWriteSync(pb: PPCWritePBPtr): OSErr;
  409.     {$IFC NOT GENERATINGCFM}
  410.     INLINE $205F, $7006, $A0DD, $3E80;
  411.     {$ENDC}
  412. FUNCTION PPCWriteAsync(pb: PPCWritePBPtr): OSErr;
  413.     {$IFC NOT GENERATINGCFM}
  414.     INLINE $205F, $7006, $A4DD, $3E80;
  415.     {$ENDC}
  416. FUNCTION PPCReadSync(pb: PPCReadPBPtr): OSErr;
  417.     {$IFC NOT GENERATINGCFM}
  418.     INLINE $205F, $7007, $A0DD, $3E80;
  419.     {$ENDC}
  420. FUNCTION PPCReadAsync(pb: PPCReadPBPtr): OSErr;
  421.     {$IFC NOT GENERATINGCFM}
  422.     INLINE $205F, $7007, $A4DD, $3E80;
  423.     {$ENDC}
  424. FUNCTION PPCEndSync(pb: PPCEndPBPtr): OSErr;
  425.     {$IFC NOT GENERATINGCFM}
  426.     INLINE $205F, $7008, $A0DD, $3E80;
  427.     {$ENDC}
  428. FUNCTION PPCEndAsync(pb: PPCEndPBPtr): OSErr;
  429.     {$IFC NOT GENERATINGCFM}
  430.     INLINE $205F, $7008, $A4DD, $3E80;
  431.     {$ENDC}
  432. FUNCTION PPCCloseSync(pb: PPCClosePBPtr): OSErr;
  433.     {$IFC NOT GENERATINGCFM}
  434.     INLINE $205F, $7009, $A0DD, $3E80;
  435.     {$ENDC}
  436. FUNCTION PPCCloseAsync(pb: PPCClosePBPtr): OSErr;
  437.     {$IFC NOT GENERATINGCFM}
  438.     INLINE $205F, $7009, $A4DD, $3E80;
  439.     {$ENDC}
  440. FUNCTION IPCListPortsSync(pb: IPCListPortsPBPtr): OSErr;
  441.     {$IFC NOT GENERATINGCFM}
  442.     INLINE $205F, $700A, $A0DD, $3E80;
  443.     {$ENDC}
  444. FUNCTION IPCListPortsAsync(pb: IPCListPortsPBPtr): OSErr;
  445.     {$IFC NOT GENERATINGCFM}
  446.     INLINE $205F, $700A, $A4DD, $3E80;
  447.     {$ENDC}
  448. FUNCTION DeleteUserIdentity(userRef: LONGINT): OSErr;
  449. FUNCTION GetDefaultUser(VAR userRef: LONGINT; VAR userName: Str32): OSErr;
  450. FUNCTION StartSecureSession(pb: PPCStartPBPtr; VAR userName: Str32; useDefault: BOOLEAN; allowGuest: BOOLEAN; VAR guestSelected: BOOLEAN; prompt: ConstStr255Param): OSErr;
  451. TYPE
  452.     PPCFilterProcPtr = ProcPtr;  { FUNCTION PPCFilter(name: LocationNamePtr; port: PortInfoPtr): BOOLEAN; }
  453.     PPCFilterUPP = UniversalProcPtr;
  454.  
  455. CONST
  456.     uppPPCCompProcInfo = $000000C0; { PROCEDURE (4 byte param); }
  457.     uppPPCFilterProcInfo = $000003D0; { FUNCTION (4 byte param, 4 byte param): 1 byte result; }
  458.  
  459. FUNCTION NewPPCCompProc(userRoutine: PPCCompProcPtr): PPCCompUPP;
  460.     {$IFC NOT GENERATINGCFM }
  461.     INLINE $2E9F;
  462.     {$ENDC}
  463.  
  464. FUNCTION NewPPCFilterProc(userRoutine: PPCFilterProcPtr): PPCFilterUPP;
  465.     {$IFC NOT GENERATINGCFM }
  466.     INLINE $2E9F;
  467.     {$ENDC}
  468.  
  469. PROCEDURE CallPPCCompProc(pb: PPCParamBlockPtr; userRoutine: PPCCompUPP);
  470.     {$IFC NOT GENERATINGCFM}
  471.     INLINE $205F, $4E90;
  472.     {$ENDC}
  473.  
  474. FUNCTION CallPPCFilterProc(name: LocationNamePtr; port: PortInfoPtr; userRoutine: PPCFilterUPP): BOOLEAN;
  475.     {$IFC NOT GENERATINGCFM}
  476.     INLINE $205F, $4E90;
  477.     {$ENDC}
  478.  
  479. FUNCTION PPCBrowser(prompt: ConstStr255Param; applListLabel: ConstStr255Param; defaultSpecified: BOOLEAN; VAR theLocation: LocationNameRec; VAR thePortInfo: PortInfoRec; portFilter: PPCFilterUPP; theLocNBPType: ConstStr32Param): OSErr;
  480.     {$IFC NOT GENERATINGCFM}
  481.     INLINE $303C, $0D00, $A82B;
  482.     {$ENDC}
  483. {$IFC OLDROUTINENAMES }
  484. {
  485.   The ParamBlock calls with the "Sync" or "Async" suffix are being phased out.
  486. }
  487. FUNCTION PPCOpen(pb: PPCOpenPBPtr; async: BOOLEAN): OSErr;
  488. FUNCTION PPCInform(pb: PPCInformPBPtr; async: BOOLEAN): OSErr;
  489. FUNCTION PPCStart(pb: PPCStartPBPtr; async: BOOLEAN): OSErr;
  490. FUNCTION PPCAccept(pb: PPCAcceptPBPtr; async: BOOLEAN): OSErr;
  491. FUNCTION PPCReject(pb: PPCRejectPBPtr; async: BOOLEAN): OSErr;
  492. FUNCTION PPCWrite(pb: PPCWritePBPtr; async: BOOLEAN): OSErr;
  493. FUNCTION PPCRead(pb: PPCReadPBPtr; async: BOOLEAN): OSErr;
  494. FUNCTION PPCEnd(pb: PPCEndPBPtr; async: BOOLEAN): OSErr;
  495. FUNCTION PPCClose(pb: PPCClosePBPtr; async: BOOLEAN): OSErr;
  496. FUNCTION IPCListPorts(pb: IPCListPortsPBPtr; async: BOOLEAN): OSErr;
  497. {$ENDC}
  498.  
  499. {$ALIGN RESET}
  500. {$POP}
  501.  
  502. {$SETC UsingIncludes := PPCToolboxIncludes}
  503.  
  504. {$ENDC} {__PPCTOOLBOX__}
  505.  
  506. {$IFC NOT UsingIncludes}
  507.  END.
  508. {$ENDC}
  509.